/*
* jQuery UI Accordion 1.8.7
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI/Accordion
*
* Depends:
*	jquery.ui.core.js
*	jquery.ui.widget.js
*/
(function ($, undefined) {
    $.widget("ui.accordion", {
        options: {
            active: 0,
            animated: "slide",
            autoHeight: true,
            clearStyle: false,
            collapsible: false,
            event: "click",
            fillSpace: false,
            header: "> li > :first-child,> :not(li):even",
            icons: {
                header: "ui-icon-triangle-1-e",
                headerSelected: "ui-icon-triangle-1-s"
            },
            navigation: false,
            navigationFilter: function () {
                return this.href.toLowerCase() === location.href.toLowerCase();
            }
        },

        _create: function () {
            var self = this,
			options = self.options;

            self.running = 0;

            self.element
			.addClass("ui-accordion ui-widget ui-helper-reset")
            // in lack of child-selectors in CSS
            // we need to mark top-LIs in a UL-accordion for some IE-fix
			.children("li")
				.addClass("ui-accordion-li-fix");

            self.headers = self.element.find(options.header)
			.addClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all")
			.bind("mouseenter.accordion", function () {
			    if (options.disabled) {
			        return;
			    }
			    $(this).addClass("ui-state-hover");
			})
			.bind("mouseleave.accordion", function () {
			    if (options.disabled) {
			        return;
			    }
			    $(this).removeClass("ui-state-hover");
			})
			.bind("focus.accordion", function () {
			    if (options.disabled) {
			        return;
			    }
			    $(this).addClass("ui-state-focus");
			})
			.bind("blur.accordion", function () {
			    if (options.disabled) {
			        return;
			    }
			    $(this).removeClass("ui-state-focus");
			});

            self.headers.next()
			.addClass("ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom");

            if (options.navigation) {
                var current = self.element.find("a").filter(options.navigationFilter).eq(0);
                if (current.length) {
                    var header = current.closest(".ui-accordion-header");
                    if (header.length) {
                        // anchor within header
                        self.active = header;
                    } else {
                        // anchor within content
                        self.active = current.closest(".ui-accordion-content").prev();
                    }
                }
            }

            self.active = self._findActive(self.active || options.active)
			.addClass("ui-state-default ui-state-active")
			.toggleClass("ui-corner-all")
			.toggleClass("ui-corner-top");
            self.active.next().addClass("ui-accordion-content-active");

            self._createIcons();
            self.resize();

            // ARIA
            self.element.attr("role", "tablist");

            self.headers
			.attr("role", "tab")
			.bind("keydown.accordion", function (event) {
			    return self._keydown(event);
			})
			.next()
				.attr("role", "tabpanel");

            self.headers
			.not(self.active || "")
			.attr({
			    "aria-expanded": "false",
			    tabIndex: -1
			})
			.next()
				.hide();

            // make sure at least one header is in the tab order
            if (!self.active.length) {
                self.headers.eq(0).attr("tabIndex", 0);
            } else {
                self.active
				.attr({
				    "aria-expanded": "true",
				    tabIndex: 0
				});
            }

            // only need links in tab order for Safari
            if (!$.browser.safari) {
                self.headers.find("a").attr("tabIndex", -1);
            }

            if (options.event) {
                self.headers.bind(options.event.split(" ").join(".accordion ") + ".accordion", function (event) {
                    self._clickHandler.call(self, event, this);
                    event.preventDefault();
                });
            }
        },

        _createIcons: function () {
            var options = this.options;
            if (options.icons) {
                $("<span></span>")
				.addClass("ui-icon " + options.icons.header)
				.prependTo(this.headers);
                this.active.children(".ui-icon")
				.toggleClass(options.icons.header)
				.toggleClass(options.icons.headerSelected);
                this.element.addClass("ui-accordion-icons");
            }
        },

        _destroyIcons: function () {
            this.headers.children(".ui-icon").remove();
            this.element.removeClass("ui-accordion-icons");
        },

        destroy: function () {
            var options = this.options;

            this.element
			.removeClass("ui-accordion ui-widget ui-helper-reset")
			.removeAttr("role");

            this.headers
			.unbind(".accordion")
			.removeClass("ui-accordion-header ui-accordion-disabled ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top")
			.removeAttr("role")
			.removeAttr("aria-expanded")
			.removeAttr("tabIndex");

            this.headers.find("a").removeAttr("tabIndex");
            this._destroyIcons();
            var contents = this.headers.next()
			.css("display", "")
			.removeAttr("role")
			.removeClass("ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-accordion-disabled ui-state-disabled");
            if (options.autoHeight || options.fillHeight) {
                contents.css("height", "");
            }

            return $.Widget.prototype.destroy.call(this);
        },

        _setOption: function (key, value) {
            $.Widget.prototype._setOption.apply(this, arguments);

            if (key == "active") {
                this.activate(value);
            }
            if (key == "icons") {
                this._destroyIcons();
                if (value) {
                    this._createIcons();
                }
            }
            // #5332 - opacity doesn't cascade to positioned elements in IE
            // so we need to add the disabled class to the headers and panels
            if (key == "disabled") {
                this.headers.add(this.headers.next())
				[value ? "addClass" : "removeClass"](
					"ui-accordion-disabled ui-state-disabled");
            }
        },

        _keydown: function (event) {
            if (this.options.disabled || event.altKey || event.ctrlKey) {
                return;
            }

            var keyCode = $.ui.keyCode,
			length = this.headers.length,
			currentIndex = this.headers.index(event.target),
			toFocus = false;

            switch (event.keyCode) {
                case keyCode.RIGHT:
                case keyCode.DOWN:
                    toFocus = this.headers[(currentIndex + 1) % length];
                    break;
                case keyCode.LEFT:
                case keyCode.UP:
                    toFocus = this.headers[(currentIndex - 1 + length) % length];
                    break;
                case keyCode.SPACE:
                case keyCode.ENTER:
                    this._clickHandler({ target: event.target }, event.target);
                    event.preventDefault();
            }

            if (toFocus) {
                $(event.target).attr("tabIndex", -1);
                $(toFocus).attr("tabIndex", 0);
                toFocus.focus();
                return false;
            }

            return true;
        },

        resize: function () {
            var options = this.options,
			maxHeight;

            if (options.fillSpace) {
                if ($.browser.msie) {
                    var defOverflow = this.element.parent().css("overflow");
                    this.element.parent().css("overflow", "hidden");
                }
                maxHeight = this.element.parent().height();
                if ($.browser.msie) {
                    this.element.parent().css("overflow", defOverflow);
                }

                this.headers.each(function () {
                    maxHeight -= $(this).outerHeight(true);
                });

                this.headers.next()
				.each(function () {
				    $(this).height(Math.max(0, maxHeight -
						$(this).innerHeight() + $(this).height()));
				})
				.css("overflow", "auto");
            } else if (options.autoHeight) {
                maxHeight = 0;
                this.headers.next()
				.each(function () {
				    maxHeight = Math.max(maxHeight, $(this).height("").height());
				})
				.height(maxHeight);
            }

            return this;
        },

        activate: function (index) {
            // TODO this gets called on init, changing the option without an explicit call for that
            this.options.active = index;
            // call clickHandler with custom event
            var active = this._findActive(index)[0];
            this._clickHandler({ target: active }, active);

            return this;
        },

        _findActive: function (selector) {
            return selector
			? typeof selector === "number"
				? this.headers.filter(":eq(" + selector + ")")
				: this.headers.not(this.headers.not(selector))
			: selector === false
				? $([])
				: this.headers.filter(":eq(0)");
        },

        // TODO isn't event.target enough? why the separate target argument?
        _clickHandler: function (event, target) {
            var options = this.options;
            if (options.disabled) {
                return;
            }

            // called only when using activate(false) to close all parts programmatically
            if (!event.target) {
                if (!options.collapsible) {
                    return;
                }
                this.active
				.removeClass("ui-state-active ui-corner-top")
				.addClass("ui-state-default ui-corner-all")
				.children(".ui-icon")
					.removeClass(options.icons.headerSelected)
					.addClass(options.icons.header);
                this.active.next().addClass("ui-accordion-content-active");
                var toHide = this.active.next(),
				data = {
				    options: options,
				    newHeader: $([]),
				    oldHeader: options.active,
				    newContent: $([]),
				    oldContent: toHide
				},
				toShow = (this.active = $([]));
                this._toggle(toShow, toHide, data);
                return;
            }

            // get the click target
            var clicked = $(event.currentTarget || target),
			clickedIsActive = clicked[0] === this.active[0];

            // TODO the option is changed, is that correct?
            // TODO if it is correct, shouldn't that happen after determining that the click is valid?
            options.active = options.collapsible && clickedIsActive ?
			false :
			this.headers.index(clicked);

            // if animations are still active, or the active header is the target, ignore click
            if (this.running || (!options.collapsible && clickedIsActive)) {
                return;
            }

            // switch classes
            this.active
			.removeClass("ui-state-active ui-corner-top")
			.addClass("ui-state-default ui-corner-all")
			.children(".ui-icon")
				.removeClass(options.icons.headerSelected)
				.addClass(options.icons.header);
            if (!clickedIsActive) {
                clicked
				.removeClass("ui-state-default ui-corner-all")
				.addClass("ui-state-active ui-corner-top")
				.children(".ui-icon")
					.removeClass(options.icons.header)
					.addClass(options.icons.headerSelected);
                clicked
				.next()
				.addClass("ui-accordion-content-active");
            }

            // find elements to show and hide
            var toShow = clicked.next(),
			toHide = this.active.next(),
			data = {
			    options: options,
			    newHeader: clickedIsActive && options.collapsible ? $([]) : clicked,
			    oldHeader: this.active,
			    newContent: clickedIsActive && options.collapsible ? $([]) : toShow,
			    oldContent: toHide
			},
			down = this.headers.index(this.active[0]) > this.headers.index(clicked[0]);

            this.active = clickedIsActive ? $([]) : clicked;
            this._toggle(toShow, toHide, data, clickedIsActive, down);

            return;
        },

        _toggle: function (toShow, toHide, data, clickedIsActive, down) {
            var self = this,
			options = self.options;

            self.toShow = toShow;
            self.toHide = toHide;
            self.data = data;

            var complete = function () {
                if (!self) {
                    return;
                }
                return self._completed.apply(self, arguments);
            };

            // trigger changestart event
            self._trigger("changestart", null, self.data);

            // count elements to animate
            self.running = toHide.size() === 0 ? toShow.size() : toHide.size();

            if (options.animated) {
                var animOptions = {};

                if (options.collapsible && clickedIsActive) {
                    animOptions = {
                        toShow: $([]),
                        toHide: toHide,
                        complete: complete,
                        down: down,
                        autoHeight: options.autoHeight || options.fillSpace
                    };
                } else {
                    animOptions = {
                        toShow: toShow,
                        toHide: toHide,
                        complete: complete,
                        down: down,
                        autoHeight: options.autoHeight || options.fillSpace
                    };
                }

                if (!options.proxied) {
                    options.proxied = options.animated;
                }

                if (!options.proxiedDuration) {
                    options.proxiedDuration = options.duration;
                }

                options.animated = $.isFunction(options.proxied) ?
				options.proxied(animOptions) :
				options.proxied;

                options.duration = $.isFunction(options.proxiedDuration) ?
				options.proxiedDuration(animOptions) :
				options.proxiedDuration;

                var animations = $.ui.accordion.animations,
				duration = options.duration,
				easing = options.animated;

                if (easing && !animations[easing] && !$.easing[easing]) {
                    easing = "slide";
                }
                if (!animations[easing]) {
                    animations[easing] = function (options) {
                        this.slide(options, {
                            easing: easing,
                            duration: duration || 700
                        });
                    };
                }

                animations[easing](animOptions);
            } else {
                if (options.collapsible && clickedIsActive) {
                    toShow.toggle();
                } else {
                    toHide.hide();
                    toShow.show();
                }

                complete(true);
            }

            // TODO assert that the blur and focus triggers are really necessary, remove otherwise
            toHide.prev()
			.attr({
			    "aria-expanded": "false",
			    tabIndex: -1
			})
			.blur();
            toShow.prev()
			.attr({
			    "aria-expanded": "true",
			    tabIndex: 0
			})
			.focus();
        },

        _completed: function (cancel) {
            this.running = cancel ? 0 : --this.running;
            if (this.running) {
                return;
            }

            if (this.options.clearStyle) {
                this.toShow.add(this.toHide).css({
                    height: "",
                    overflow: ""
                });
            }

            // other classes are removed before the animation; this one needs to stay until completed
            this.toHide.removeClass("ui-accordion-content-active");

            this._trigger("change", null, this.data);
        }
    });

    $.extend($.ui.accordion, {
        version: "1.8.7",
        animations: {
            slide: function (options, additions) {
                options = $.extend({
                    easing: "swing",
                    duration: 300
                }, options, additions);
                if (!options.toHide.size()) {
                    options.toShow.animate({
                        height: "show",
                        paddingTop: "show",
                        paddingBottom: "show"
                    }, options);
                    return;
                }
                if (!options.toShow.size()) {
                    options.toHide.animate({
                        height: "hide",
                        paddingTop: "hide",
                        paddingBottom: "hide"
                    }, options);
                    return;
                }
                var overflow = options.toShow.css("overflow"),
				percentDone = 0,
				showProps = {},
				hideProps = {},
				fxAttrs = ["height", "paddingTop", "paddingBottom"],
				originalWidth;
                // fix width before calculating height of hidden element
                var s = options.toShow;
                originalWidth = s[0].style.width;
                s.width(parseInt(s.parent().width(), 10)
				- parseInt(s.css("paddingLeft"), 10)
				- parseInt(s.css("paddingRight"), 10)
				- (parseInt(s.css("borderLeftWidth"), 10) || 0)
				- (parseInt(s.css("borderRightWidth"), 10) || 0));

                $.each(fxAttrs, function (i, prop) {
                    hideProps[prop] = "hide";

                    var parts = ("" + $.css(options.toShow[0], prop)).match(/^([\d+-.]+)(.*)$/);
                    showProps[prop] = {
                        value: parts[1],
                        unit: parts[2] || "px"
                    };
                });
                options.toShow.css({ height: 0, overflow: "hidden" }).show();
                options.toHide
				.filter(":hidden")
					.each(options.complete)
				.end()
				.filter(":visible")
				.animate(hideProps, {
				    step: function (now, settings) {
				        // only calculate the percent when animating height
				        // IE gets very inconsistent results when animating elements
				        // with small values, which is common for padding
				        if (settings.prop == "height") {
				            percentDone = (settings.end - settings.start === 0) ? 0 :
							(settings.now - settings.start) / (settings.end - settings.start);
				        }

				        options.toShow[0].style[settings.prop] =
						(percentDone * showProps[settings.prop].value)
						+ showProps[settings.prop].unit;
				    },
				    duration: options.duration,
				    easing: options.easing,
				    complete: function () {
				        if (!options.autoHeight) {
				            options.toShow.css("height", "");
				        }
				        options.toShow.css({
				            width: originalWidth,
				            overflow: overflow
				        });
				        options.complete();
				    }
				});
            },
            bounceslide: function (options) {
                this.slide(options, {
                    easing: options.down ? "easeOutBounce" : "swing",
                    duration: options.down ? 1000 : 200
                });
            }
        }
    });
})(jQuery);